# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def lcaDeepestLeaves(self, root: TreeNode) -> TreeNode:
        def dfs(node, depth, father):
            """返回节点，深度
            输入节点，深度，父节点
            """
            # 如果空节点，返回父节点及深度
            if node == None:
                return father, depth-1
            # 否则分别计算左右子树的目标节点
            a1, d1 = dfs(node.left, depth+1, node)
            a2, d2 = dfs(node.right, depth+1, node)
            # 选较深的，相同深度则选本节点
            if d1 > d2:
                return a1, d1
            elif d1 < d2:
                return a2, d2
            else:
                return node, d1
        
        def dfs1(node, depth):
            """避免传递父节点，对左右子树进行了检查
            """
            if node.left != None:
                if node.right != None:
                    a1, d1 = dfs(node.left, depth+1)
                    a2, d2 = dfs(node.right, depth+1)
                    if d1 > d2:
                        return a1, d1
                    elif d1 < d2:
                        return a2, d2
                    else:
                        return node, d1
                else:
                    return dfs(node.left, depth+1)
            else:
                if node.right != None:
                    return dfs(node.right, depth+1)
                else:
                    return node, depth
        
        a,d = dfs(root, 0, None)
        # a,d = dfs1(root, 0)
        return a